package com.xxx.lambda;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.concurrent.Callable;
import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.function.Supplier;

/**
 * @version v1.0
 * @Description:
 * @Author zhanzhongxin
 * @Date 2021/7/26 11:02
 * @Copyright 博为峰
 */
public class Lam01 {
    /*
        Lambada表达式:
        1.jdk1.8引入的新语法
        2.Lambada操作符（箭头操作费） ->

        语法格式:
        1.无参，无返回值     ()->{}
        2.一个参数，无返回值  ()省略不写，{}中只有一行代码时，可以省略
        3.一个参数，有返回值  ()省略不写，{}中只有一行代码时，{}可以省略,return可以省略
        4.多个参数

        Lambada本质就是创建（函数式）接口的实现类对象

        函数式接口:只包含一个抽象方法的接口  @FunctionalInterface
        1.Consumer<T> 消费型接口  void accept(T t)
        2.Supplier<T> 供给型接口  T get()
        3.Function<T,R> 函数型接口 R apply(T t)
        4.Predicate<T> 断言型接口 boolean test(T t)


     */
    public static void main(String[] args) {
//        m2();
//        m3();
//        m4();
        ArrayList<Integer> integers = new ArrayList<>();
//        Supplier<Integer> supplier = new Supplier<Integer>() {
//            @Override
//            public Integer get() {
//                return 66;
//            }
//        };
//        System.out.println(supplier.get());
        Supplier<Integer> supplier = () -> {
            return 66;
        };
        System.out.println(supplier.get());
    }

    private static void m4() {
//        Predicate<String> predicate = new Predicate<String>() {
//            @Override
//            public boolean test(String s) {
//                return s.equals("abc");
//            }
//        };
//        System.out.println(predicate.test("abc"));

        Predicate<String> predicate = s -> s.equals("abc");
        System.out.println(predicate.test("abc"));
    }

    private static void m3() {
//        Consumer<String> consumer = new Consumer<String>() {
//            @Override
//            public void accept(String s) {
//                System.out.println(s);
//            }
//        };
//        consumer.accept("abc");
        Consumer<String> consumer = s -> System.out.println(s);
        consumer.accept("Lambada表达式方式");
    }

    private static void m2() {
        //        m1();
//        Runnable runnable = new Runnable() {
//            @Override
//            public void run() {
//                System.out.println("匿名内部类方式");
//            }
//        };
//        runnable.run();

        Runnable runnable = () -> {
            System.out.println("匿名内部类方式");
        };
    }

    private static void m1() {
        ArrayList<Student> students = new ArrayList<Student>();
        students.add(new Student("zhangsan", 20));
        students.add(new Student("lisi", 10));
        students.add(new Student("wangwu", 30));
        students.add(new Student("zhaoliu", 22));

        students.sort(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return o1.getAge() - o2.getAge();
            }
        });

        students.sort((o1, o2) -> o1.getAge() - o2.getAge());

        for (Student student : students) {
            System.out.println("student = " + student);
        }
    }
}
